// pages/calculate/calculate.js
import { PrecisionMath, cal } from './util.js';

var sceneReadyBehavior = require('../../behavior-scene/scene-ready');

Page({
  behaviors: [sceneReadyBehavior],
  /**
   * 页面的初始数据
   */
  data: {
    // 当前阶段 (1-4)
    currentStage: 1,

    // 各阶段状态: 'pending', 'success', 'failed'
    stageStatus: ['pending', 'pending', 'pending', 'pending'],

    // 卡片折叠状态
    cardCollapsed: [false, false, false, false],

    // 计算状态
    calculating: false,

    // 页面控制状态
    hasReturnedFromNext: false, // 是否从下一阶段返回
    maxReachedStage: 1, // 用户曾经到达的最大阶段
    formChanged: false, // 表单是否发生变化
    stage1FormChanged: false, // 阶段1表单是否发生变化

    // 表单数据
    formData: {
      // 机器名称
      machineName: '',
      // 轴名称
      axisName: '',
      // 日期
      date: new Date().toISOString().slice(0, 10),
      // 运动模式
      motionMode: 'point-to-point',
      // 运动形状
      motionShape: 'trapezoidal',
      // 加速时间
      accelerationTime: 0,
      // 运行时间
      runningTime: 0,
      // 总质量
      totalMass: 0,
      // 总距离
      totalDistance: 0,
      // 总时间
      totalTime: 0,
      // 最大加速度
      maxAcceleration: 0,
      // 最大速度
      maxSpeed: 0,
      // 停留时间
      dwellTime: 0,
      // 倾斜角度
      inclineAngle: 0,
      // 环境温度
      ambientTemp: 0,
      // 反作用力
      reactionForce: 0,
      // 估计阻力
      estimatedResistance: 0,
      // 摩擦系数
      frictionCoeff: 0,
      // 正向吸力
      forwardSuction: 0,
      // 工作阻力
      workResistance: 0,
      // 拖链阻力
      dragChainResistance: 0,
      // 摩擦力
      frictionForce: 0,
    },

    calcResults: {},

    // 筛选参数
    safetyMargin: {
      lower: 50,
      upper: 200,
    },
    coolingMethods: [],
    coreType: '',

    // 筛选结果
    filteredMotors: [], // 原始筛选结果
    displayedMotors: [], // 当前显示的电机列表（分页加载）
    
    // 分页懒加载相关
    pageSize: 20, // 每页显示数量
    currentPage: 1, // 当前页码
    totalPages: 0, // 总页数
    isLoading: false, // 是否正在加载
    hasMore: true, // 是否还有更多数据

    // 电机选择
    motorOptions: [],
    selectedMotorIndex: 0,
    selectedMotor: {},

    // 筛选结果展示控制
    motorListCollapsed: false,
    motorDetailExpanded: [],
    selectedMotorFromList: null, // 从列表中选中的电机索引

    // 导出状态
    hasExportedSolution: false, // 是否已经导出过控制方案

    // 图表数据
    speedChartData: {},

    forceChartData: {},

    db_id: null, // 保存数据库的id, 后续更新使用

    // 3D模型相关
    show3DModel: [], // 控制每个电机的3D模型显示状态
    modelUrl: '' // 默认模型URL
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // TODO 
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('计算页面显示');

    // 验证数据结构的完整性
    if (!this.data.cardCollapsed || !Array.isArray(this.data.cardCollapsed)) {
      console.warn('检测到数据异常，重新初始化...');
      this.initializePageData();
    }
  },

  /**
   * 初始化页面数据
   */
     initializePageData() {
     this.setData({
       // 当前阶段 (1-4)
       currentStage: 1,
       // 各阶段状态: 'pending', 'success', 'failed'
       stageStatus: ['pending', 'pending', 'pending', 'pending'],
       // 卡片折叠状态
       cardCollapsed: [false, false, false, false],
       // 计算状态
       calculating: false,
       // 页面控制状态
       hasReturnedFromNext: false,
       maxReachedStage: 1,
       formChanged: false,
       stage1FormChanged: false,
       // 计算结果
       calcResults: {},
       // 筛选结果
       filteredMotors: [],
       displayedMotors: [],
       // 重置分页状态
       currentPage: 1,
       totalPages: 0,
       isLoading: false,
       hasMore: true,
       motorOptions: [],
       selectedMotorIndex: 0,
       selectedMotor: {},
       // 重置选中状态
       selectedMotorFromList: null,
       motorListCollapsed: false,
       motorDetailExpanded: [], // 初始化为空数组，在筛选时会正确初始化
       // 重置导出状态
       hasExportedSolution: false,
       // 重置3D模型显示状态
       show3DModel: []
     });
     console.log('页面数据已重新初始化');
   },

  /**
   * 卡片折叠切换
   */
  toggleCard(e) {
    console.log('toggleCard called with event:', e);
    console.log('Current data state:', this.data);

    const index = parseInt(e.currentTarget.dataset.index);
    console.log('Parsed index:', index);

    // 确保cardCollapsed数组存在
    if (!this.data.cardCollapsed) {
      console.error('cardCollapsed array is not initialized');
      this.setData({
        cardCollapsed: [false, false, false, false]
      });
      return;
    }

    // 确保index是有效的
    if (isNaN(index) || index < 0 || index >= this.data.cardCollapsed.length) {
      console.error('Invalid card index:', index, 'cardCollapsed length:', this.data.cardCollapsed.length);
      return;
    }

    // 创建新的数组副本
    const collapsed = [...this.data.cardCollapsed];
    collapsed[index] = !collapsed[index];

    console.log('New collapsed state:', collapsed);

    this.setData({
      cardCollapsed: collapsed
    });

    console.log(`Card ${index} toggled to:`, collapsed[index] ? 'collapsed' : 'expanded');
  },

  /**
   * 表单输入处理
   */
  onInputChange(e) {
    const field = e.currentTarget.dataset.field;
    const value = e.detail.value;
    this.setData({
      [`formData.${field}`]: value
    });

    // 标记表单已变化
    this.markFormChanged(field);

    // 如果是参数二的字段，实时计算结果
    this.updateParameterResults(field, value);
  },

  /**
   * 更新参数计算结果
   */
  updateParameterResults(field, value) {
    const calcResults = {
      ...this.data.calcResults
    };

    // 将输入值转换为数字，空字符串转为0
    const numValue = value === '' ? 0 : parseFloat(value);
    
    if (!isNaN(numValue) && numValue > 0) {

      switch (field) {
        case 'totalMass':
          calcResults.totalMassResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 1.2)) + ' kg';
          break;
        case 'totalDistance':
          calcResults.totalDistanceResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 0.95)) + ' m';
          break;
        case 'maxAcceleration':
          calcResults.maxAccelerationResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 1.1)) + ' m/s²';
          break;
        case 'maxSpeed':
          calcResults.maxSpeedResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 0.98)) + ' m/s';
          break;
        case 'totalTime':
          calcResults.totalTimeResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 1.05)) + ' s';
          break;
        case 'dwellTime':
          calcResults.dwellTimeResult = PrecisionMath.toFixed5(PrecisionMath.add(numValue, 0.5)) + ' s';
          break;
        case 'inclineAngle':
          calcResults.inclineAngleResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 1.05)) + ' °';
          break;
        case 'ambientTemp':
          calcResults.ambientTempResult = PrecisionMath.toFixed5(PrecisionMath.add(numValue, 5)) + ' °C';
          break;
        case 'reactionForce':
          calcResults.reactionForceResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 1.15)) + ' N';
          break;
        case 'estimatedResistance':
          calcResults.estimatedResistanceResult = PrecisionMath.toFixed5(PrecisionMath.multiply(numValue, 0.9)) + ' N';
          break;
      }

      this.setData({
        calcResults
      });
    } else {
      // 如果输入为空，清空对应的计算结果
      switch (field) {
        case 'totalMass':
          calcResults.totalMassResult = '--';
          break;
        case 'totalDistance':
          calcResults.totalDistanceResult = '--';
          break;
        case 'maxAcceleration':
          calcResults.maxAccelerationResult = '--';
          break;
        case 'maxSpeed':
          calcResults.maxSpeedResult = '--';
          break;
        case 'totalTime':
          calcResults.totalTimeResult = '--';
          break;
        case 'dwellTime':
          calcResults.dwellTimeResult = '--';
          break;
        case 'inclineAngle':
          calcResults.inclineAngleResult = '--';
          break;
        case 'ambientTemp':
          calcResults.ambientTempResult = '--';
          break;
        case 'reactionForce':
          calcResults.reactionForceResult = '--';
          break;
        case 'estimatedResistance':
          calcResults.estimatedResistanceResult = '--';
          break;
      }

      this.setData({
        calcResults
      });
    }
  },

  /**
   * 运动模式变化
   */
  onMotionModeChange(e) {
    this.setData({
      'formData.motionMode': e.detail
    });
    // 标记表单已变化
    this.markFormChanged('motionMode');
  },

  /**
   * 运动形状变化
   */
  onMotionShapeChange(e) {
    console.log('运动形状变化:', e.detail);
    this.setData({
      'formData.motionShape': e.detail
    });
    // 标记表单已变化
    this.markFormChanged('motionShape');
  },

  /**
   * 重置表单
   */
  resetForm() {
    this.setData({
      formData: {
        machineName: '',
        axisName: '',
        date: new Date().toISOString().slice(0, 10),
        motionMode: 'point-to-point',
        motionShape: 'trapezoidal',
        // 加速时间（自定义模式下）
        accelerationTime: 0,
        // 运行时间（自定义模式下）
        runningTime: 0,
        totalMass: 0,
        totalDistance: 0,
        maxAcceleration: 0,
        maxSpeed: 0,
        dwellTime: 0,
        inclineAngle: 0,
        ambientTemp: 20,
        reactionForce: 0,
        estimatedResistance: 0,
        frictionCoeff: 0,
        forwardSuction: 0,
        workResistance: 0,
        dragChainResistance: 0,
        frictionForce: 0,
      },
      // 重置状态标记
      formChanged: false,
      stage1FormChanged: false,
      maxReachedStage: 1
    });
    wx.showToast({
      title: '表单已重置',
      icon: 'success'
    });
  },



  /**
   * 参数计算
   */
  calculateParams() {
    // 检查是否允许计算
    if (!this.canCalculate()) {
      return;
    }

    // 验证必填字段
    if (!this.validateStage1()) {
      return;
    }

    this.setData({
      calculating: true
    });

    // 判断加速时间和运动时间的比值
    

    // 执行计算
    const results = cal(this.data.formData)
    console.log("计算结果", results)
  
    // 更新状态
    const stageStatus = this.data.stageStatus;
    stageStatus[0] = 'success';
    this.setData({
      calculating: false,
      calcResults: results,
      stageStatus: stageStatus,
      currentStage: 2,
      // 更新最大到达阶段
      maxReachedStage: Math.max(this.data.maxReachedStage, 2),
      // 重置表单变化标记
      formChanged: false,
      stage1FormChanged: false,
      hasReturnedFromNext: false
    });

    this.setData({
      speedChartData: {
        title: '速度-时间',
        xAxisData: results.speedTimeXPoints,
        yAxisData: results.speedTimeYPoints,
        xAxisName: '时间(s)',
        yAxisName: '速度(m/s)',
        lineColor: '#ff6b6b'
      },
      forceChartData: {
        title: '力-时间',
        xAxisData: results.forceTimeXPoints,
        yAxisData: results.forceTimeYPoints,
        xAxisName: '时间(s)',
        yAxisName: '力(N)',
        lineColor: '#4ecdc4'
      }
    });
    
  },

  /**
   * 根据计算结果更新图表数据
   */
  updateChartsWithCalculatedData(formData, results) {
    // 根据总时间和计算结果生成更真实的数据
    const totalTime = formData.totalTime || 5.0;
    const maxSpeed = formData.maxSpeed || 50;
    const accelTime = parseFloat(results.accelTime) || 1.0;
    const decelTime = parseFloat(results.decelTime) || 1.0;
    const uniformTime = parseFloat(results.uniformTime) || 3.0;

    // 生成时间轴数据（更细致的时间点）
    const timePoints = [];
    const speedPoints = [];
    const forcePoints = [];

    const timeStep = totalTime / 20; // 20个数据点

    for (let i = 0; i <= 20; i++) {
      const time = PrecisionMath.multiply(i, timeStep);
      timePoints.push(PrecisionMath.toNumber(PrecisionMath.toFixed5(time)));

      // 计算速度（梯形速度曲线）- 使用高精度计算
      let speed = 0;
      if (time <= accelTime) {
        // 加速阶段
        speed = PrecisionMath.multiply(PrecisionMath.divide(maxSpeed, accelTime), time);
      } else if (time <= PrecisionMath.add(accelTime, uniformTime)) {
        // 匀速阶段
        speed = maxSpeed;
      } else if (time <= totalTime) {
        // 减速阶段
        const decelStartTime = PrecisionMath.add(accelTime, uniformTime);
        const speedReduction = PrecisionMath.multiply(PrecisionMath.divide(maxSpeed, decelTime), PrecisionMath.subtract(time, decelStartTime));
        speed = PrecisionMath.subtract(maxSpeed, speedReduction);
      }
      speed = Math.max(0, speed);
      speedPoints.push(PrecisionMath.toNumber(PrecisionMath.toFixed5(speed)));

      // 计算力（基于加速度和负载）- 使用高精度计算
      let force = PrecisionMath.toNumber(results.supportForce, 300); // 基础支撑力
      if (time <= accelTime || time > PrecisionMath.add(accelTime, uniformTime)) {
        // 加速或减速阶段需要额外的推力
        const additionalForce = PrecisionMath.multiply(PrecisionMath.toNumber(results.peakForce, 500), 0.8);
        force = PrecisionMath.add(force, additionalForce);
      }
      // 添加一些随机波动使其更真实
      const randomVariation = PrecisionMath.multiply(PrecisionMath.subtract(Math.random(), 0.5), PrecisionMath.multiply(force, 0.1));
      force = PrecisionMath.add(force, randomVariation);
      forcePoints.push(Math.round(force));
    }

    // 更新图表数据
    this.setData({
      speedChartData: {
        title: '速度-时间曲线图（计算结果）',
        xAxisData: timePoints,
        yAxisData: speedPoints,
        xAxisName: '时间(s)',
        yAxisName: '速度(m/s)',
        lineColor: '#ce1b28'
      },
      forceChartData: {
        title: '力-时间曲线图（计算结果）',
        xAxisData: timePoints,
        yAxisData: forcePoints,
        xAxisName: '时间(s)',
        yAxisName: '力(N)',
        lineColor: '#ce1b28'
      }
    });

    console.log('图表数据已更新为计算结果');
  },

  /**
   * 验证阶段1表单
   */
  validateStage1() {
    const {
      machineName,
      axisName,
      motionMode,
      totalMass,
      totalDistance
    } = this.data.formData;

    if (!machineName) {
      wx.showToast({
        title: '请输入机器名称',
        icon: 'none'
      });
      return false;
    }
    if (!axisName) {
      wx.showToast({
        title: '请输入轴名称',
        icon: 'none'
      });
      return false;
    }
    if (!motionMode) {
      wx.showToast({
        title: '请选择运动模式',
        icon: 'none'
      });
      return false;
    }
    if (!totalMass || totalMass <= 0) {
      wx.showToast({
        title: '请输入总移动质量',
        icon: 'none'
      });
      return false;
    }
    if (!totalDistance || totalDistance <= 0) {
      wx.showToast({
        title: '请输入总运动距离',
        icon: 'none'
      });
      return false;
    }
    return true;
  },


  /**
   * 保存曲线
   */
  async saveCurve() {
    // 检查是否允许保存曲线
    if (!this.canSaveCurve()) {
      return;
    }

    try {
      wx.showLoading({
        title: '保存中...'
      });

      // 1. 上传曲线图到云存储
      const speedChartResult = await this.uploadChartToCloud("#speed-chart-canvas")
      const forceChartResult = await this.uploadChartToCloud("#force-chart-canvas")

      // 2. 获取用户 openid (从全局变量获取)
      const app = getApp();
      const openid = app.globalData.openid;
      // 检查 openid 是否存在
      if (!openid) {
        wx.hideLoading();
        wx.showModal({
          title: '登录异常',
          content: '获取用户信息失败，请重新进入小程序',
          showCancel: false,
          confirmText: '确定'
        });
        return;
      }

      // 3. 数据类型转换 - 将字符串数字转换为真正的数字类型
      const convertedFormData = this.convertFormDataTypes(this.data.formData);
      const convertedCalcResults = this.convertCalcResultsTypes(this.data.calcResults);
      
      // 4. 整理要保存的数据
      const saveData = {
        // 表单数据（已转换数据类型）
        formData: convertedFormData,
        // 计算结果（已转换数据类型）
        calcResults: convertedCalcResults,
        // 用户 openid
        openid: openid,
        // 曲线图文件ID
        speedChartFileId: speedChartResult.fileID,
        forceChartFileId: forceChartResult.fileID,
        // 创建时间
        createTime: new Date(),
        // 图表数据（用于后续可能的重新绘制）
        speedChartData: this.data.speedChartData,
        forceChartData: this.data.forceChartData,
        status: "save_success", // 保存曲线的状态，后续需要更新
      };

      // 5. 判断是更新还是新增
      const currentDbId = this.data.db_id;
      let result;
      
      if (currentDbId) {
        // 如果db_id存在，则更新现有记录
        saveData.recordId = currentDbId;
        result = await wx.cloud.callFunction({
          name: 'motor_db',
          data: {
            action: 'update_calculation',
            data: saveData
          }
        });
      } else {
        // 如果db_id不存在，则创建新记录
        result = await wx.cloud.callFunction({
          name: 'motor_db',
          data: {
            action: 'save_calculation',
            data: saveData
          }
        });
      }

      wx.hideLoading();

      if (result.result.success) {
        // 根据操作类型显示不同的提示
        const isUpdate = !!currentDbId;
        wx.showToast({
          title: isUpdate ? '更新成功' : '保存成功',
          icon: 'success'
        });
        
        // 如果是新增操作，记录返回的记录ID
        if (!isUpdate && result.result.recordId) {
          this.setData({
            db_id: result.result.recordId
          });
          console.log('计算记录已保存，记录ID:', result.result.recordId);
        } else if (isUpdate) {
          console.log('计算记录已更新，记录ID:', currentDbId);
        }
        
        // 进入下一个阶段，当前阶段设置为成功
        const stageStatus = this.data.stageStatus;
        stageStatus[1] = 'success';
        this.setData({
          stageStatus: stageStatus,
          currentStage: 3,
          // 更新最大到达阶段
          maxReachedStage: Math.max(this.data.maxReachedStage, 3),
          // 重置返回标记
          hasReturnedFromNext: false
        });

      } else {
        throw new Error(result.result.message || '操作失败');
      }

    } catch (error) {
      wx.hideLoading();
      console.error('保存曲线失败:', error);
      
      wx.showModal({
        title: '保存失败',
        content: error.message || '网络异常，请稍后重试',
        showCancel: false,
        confirmText: '确定'
      });
    }
  },

  /**
   * 安全余量下限变化
   */
  onSafetyLowerChange(e) {
    this.setData({
      'safetyMargin.lower': e.detail.value
    });
  },

  /**
   * 安全余量上限变化
   */
  onSafetyUpperChange(e) {
    this.setData({
      'safetyMargin.upper': e.detail.value
    });
  },

  /**
   * 冷却方式变化
   */
  onCoolingMethodChange(e) {
    console.log('Cooling method changed:', e.detail);
    this.setData({
      coolingMethods: e.detail
    });
  },

  /**
   * 铁芯类型变化
   */
  onCoreTypeChange(e) {
    console.log('Core type changed:', e.detail);
    this.setData({
      coreType: e.detail
    });
  },

  /**
   * 筛选电机
   */
  async filterMotors() {
    wx.showLoading({
      title: '筛选中...'
    });
   
    console.log('筛选参数', this.data.safetyMargin, this.data.coolingMethods, this.data.coreType);

    // 峰值推力
    const lowerPeakForce = PrecisionMath.multiply(this.data.calcResults.peakForce, 1 + this.data.safetyMargin.lower/100);
    const upperPeakForce = PrecisionMath.multiply(this.data.calcResults.peakForce, 1 + this.data.safetyMargin.upper/100);

    // 持续推力
    const lowerContinuousForce = PrecisionMath.multiply(this.data.calcResults.continuousForce, 1 + this.data.safetyMargin.lower/100);
    const upperContinuousForce = PrecisionMath.multiply(this.data.calcResults.continuousForce, 1 + this.data.safetyMargin.upper/100);

    const result = await wx.cloud.callFunction({
      name: 'motor_db',
      data: {
        action: 'filter_motors',
        data: { lowerContinuousForce, upperContinuousForce, lowerPeakForce, upperPeakForce, coolingMethods: this.data.coolingMethods, coreType: this.data.coreType }
      }
    })

    const filteredData = result.result.data || [];

    console.log('筛选结果:', filteredData);
    console.log('筛选结果数量:', filteredData.length);

    // 检查数据结构
    if (filteredData.length > 0) {
      console.log('第一个电机数据结构:', filteredData[0]);
    }

    // 如果没有找到匹配的电机
    if (filteredData.length === 0) {
      wx.hideLoading();
      wx.showModal({
        title: '未找到匹配电机',
        content: '根据当前筛选条件未找到匹配的电机，请调整筛选条件后重试。',
        showCancel: false,
        confirmText: '确定'
      });
      return;
    }

    // 筛选完成
    const stageStatus = this.data.stageStatus;
    stageStatus[2] = 'success';

    // 使用分页初始化数据
    this.initPaginatedData(filteredData);

    this.setData({
      motorOptions: filteredData,
      stageStatus: stageStatus,
      currentStage: 4,
      // 更新最大到达阶段
      maxReachedStage: Math.max(this.data.maxReachedStage, 4),
      // 重置返回标记
      hasReturnedFromNext: false,
      // 重置选择的电机
      selectedMotorIndex: 0,
      selectedMotor: {},
      // 重置筛选结果显示状态
      motorListCollapsed: false,
      selectedMotorFromList: null
    });

    wx.hideLoading();
    wx.showToast({
      title: `找到 ${filteredData.length} 个匹配电机，已显示前${Math.min(this.data.pageSize, filteredData.length)}个`,
      icon: 'success',
      duration: 2000
    });
  },

  /**
   * 电机选择
   */
  onMotorSelect(e) {
    const index = e.detail.value;
    const motor = this.data.motorOptions[index];

    if (!motor) {
      console.error('未找到选择的电机数据');
      return;
    }

    // 从查询结果映射完整的电机参数（根据用户提供的数据库字段映射）
    const selectedMotor = {
      // 基本信息
      model: motor.model || '未知型号',
      
      // 性能参数 - 根据用户提供的数据库字段映射
      maxForce: motor.peak_thrust || '--',                    // 峰值推力
      continuousForce: motor.continuous_thrust_100c || '--',  // 持续推力/100℃
      maxPower: '--', // 数据库中没有功率字段，暂时显示--
      continuousPower: '--', // 数据库中没有功率字段，暂时显示--
      forwardSuction: motor.magnetic_attraction_force || '--', // 磁吸力
      
      // 电气参数 - 根据用户提供的数据库字段映射
      maxCurrent: motor.peak_current || '--',                 // 峰值电流
      continuousCurrent: motor.continuous_current_100c || '--', // 持续电流/100℃
      forceConstant: motor.force_constant || '--',            // 力常数
      backEmf: motor.back_emf_constant || '--',               // 反电动势常数
      lineResistance: motor.line_resistance_25c || '--',      // 线电阻/25℃ ± 10%
      lineInductance: motor.line_inductance || '--',          // 线电感 ± 40%
      timeConstant: motor.electrical_time_constant || '--',   // 电气时间常数
      motorConstant: motor.motor_constant_25c || '--',        // 电机常数/25℃
      
      // 物理参数 - 根据用户提供的数据库字段映射
      maxCoilTemp: motor.max_coil_temperature || '--',        // 最高线圈温度
      maxVoltage: motor.max_bus_voltage || '--',              // 最高母线电压
      primaryLength: motor.mover_length || '--',              // 线圈长度
      primaryMass: motor.mover_mass || '--',                  // 线圈质量
      secondaryMass: motor.track_mass_per_meter || '--',      // 磁轨质量(每米)
      electromagneticPeriod: motor.magnetic_pitch || '--',    // 电磁周期
      
      // 其他属性
      coolingMethod: motor.cooling_method || '未知',          // 冷却方式
      coreType: motor.motor_type || '未知',                   // 电机类型
      
      // 3D模型URL
      modelUrl: motor.mode_3d_info?.url || this.data.modelUrl,
      
      // 保留原始数据库对象
      _originalData: motor
    };

    console.log('选择的电机:', selectedMotor);

    this.setData({
      selectedMotorIndex: index,
      selectedMotor: selectedMotor
    });

    wx.showToast({
      title: `已选择 ${selectedMotor.model}，其他电机已隐藏`,
      icon: 'success',
      duration: 2000
    });
  },

  /**
   * 切换筛选结果列表的折叠状态
   */
  toggleMotorList() {
    this.setData({
      motorListCollapsed: !this.data.motorListCollapsed
    });
  },

  /**
   * 初始化分页数据
   */
  initPaginatedData(allData) {
    const pageSize = this.data.pageSize;
    const totalPages = Math.ceil(allData.length / pageSize);
    const firstPageData = allData.slice(0, pageSize);
    
    console.log(`初始化分页数据 - 总数:${allData.length}, 每页:${pageSize}, 总页数:${totalPages}`);
    
    this.setData({
      filteredMotors: allData,
      displayedMotors: firstPageData,
      currentPage: 1,
      totalPages: totalPages,
      hasMore: totalPages > 1,
      isLoading: false,
      motorDetailExpanded: new Array(firstPageData.length).fill(false)
    });
  },

  /**
   * 加载更多数据
   */
  loadMoreMotors() {
    if (this.data.isLoading || !this.data.hasMore) {
      console.log('已在加载中或没有更多数据');
      return;
    }

    console.log('开始加载更多数据...');
    
    this.setData({
      isLoading: true
    });

    // 模拟网络延迟
    setTimeout(() => {
      const { currentPage, pageSize, filteredMotors, displayedMotors } = this.data;
      const nextPage = currentPage + 1;
      const startIndex = currentPage * pageSize;
      const endIndex = startIndex + pageSize;
      const nextPageData = filteredMotors.slice(startIndex, endIndex);
      
      console.log(`加载第${nextPage}页数据:`, nextPageData.length);
      
      if (nextPageData.length > 0) {
        const newDisplayedMotors = [...displayedMotors, ...nextPageData];
        const newDetailExpanded = [...this.data.motorDetailExpanded, ...new Array(nextPageData.length).fill(false)];
        
        this.setData({
          displayedMotors: newDisplayedMotors,
          motorDetailExpanded: newDetailExpanded,
          currentPage: nextPage,
          hasMore: nextPage < this.data.totalPages,
          isLoading: false
        });
        
        console.log(`已加载到第${nextPage}页，共显示${newDisplayedMotors.length}条数据`);
      } else {
        this.setData({
          hasMore: false,
          isLoading: false
        });
        console.log('没有更多数据了');
      }
    }, 500); // 模拟500ms加载延迟
  },

  /**
   * 滚动到底部事件
   */
  onScrollToLower() {
    console.log('滚动到底部，触发加载更多');
    this.loadMoreMotors();
  },

  /**
   * 切换电机详细信息的展开/折叠状态（手风琴效果）
   */
  toggleMotorDetail(e) {
    const index = parseInt(e.currentTarget.dataset.index);
    const expandedArray = [...this.data.motorDetailExpanded];
    
    console.log('toggleMotorDetail - 原始数组:', this.data.motorDetailExpanded);
    console.log('toggleMotorDetail - 点击索引:', index);
    
    // 如果数组长度不够，扩展数组
    while (expandedArray.length <= index) {
      expandedArray.push(false);
    }
    
    const wasExpanded = expandedArray[index];
    console.log('toggleMotorDetail - 之前是否展开:', wasExpanded);
    
    // 先关闭所有行
    for (let i = 0; i < expandedArray.length; i++) {
      expandedArray[i] = false;
    }
    
    // 如果当前行之前是关闭的，则展开它
    // 如果当前行之前是展开的，则保持关闭（实现折叠效果）
    if (!wasExpanded) {
      expandedArray[index] = true;
    }
    
    console.log('toggleMotorDetail - 更新后数组:', expandedArray);
    console.log('手风琴展开状态 - 索引:', index, '新状态:', expandedArray[index]);
    
    this.setData({
      motorDetailExpanded: expandedArray
    });
  },

  /**
   * 切换3D模型显示状态
   */
  toggle3DModel(e) {
    const index = parseInt(e.currentTarget.dataset.index);
    
    // 检查当前电机是否有3D模型URL
    const currentMotor = this.data.displayedMotors[index];
    if (!currentMotor || !currentMotor.mode_3d_info?.url) {
      console.log('该电机没有3D模型URL，无法显示');
      wx.showToast({
        title: '该电机暂无3D模型',
        icon: 'none'
      });
      return;
    }
    
    const show3DModelArray = [...this.data.show3DModel];
    
    console.log('toggle3DModel - 点击索引:', index);
    console.log('toggle3DModel - 原始数组:', this.data.show3DModel);
    console.log('当前电机数据:', currentMotor);
    console.log('电机3D模型URL:', currentMotor.mode_3d_info?.url);
    
    // 如果数组长度不够，扩展数组
    while (show3DModelArray.length <= index) {
      show3DModelArray.push(false);
    }
    
    // 切换当前索引的显示状态
    show3DModelArray[index] = !show3DModelArray[index];
    
    console.log('toggle3DModel - 更新后数组:', show3DModelArray);
    console.log('3D模型显示状态 - 索引:', index, '新状态:', show3DModelArray[index]);
    
    this.setData({
      show3DModel: show3DModelArray
    });
  },

  /**
   * 从筛选结果列表中选择电机
   */
  selectMotorFromList(e) {
    const displayIndex = parseInt(e.currentTarget.dataset.index); // 在displayedMotors中的索引
    const selectedMotor = this.data.displayedMotors[displayIndex];
    
    console.log('=== 选择电机开始 ===');
    console.log('显示列表索引:', displayIndex);
    console.log('选中的电机:', selectedMotor);
    
    // 找到在原始filteredMotors中的索引
    const originalIndex = this.data.filteredMotors.findIndex(motor => motor._id === selectedMotor._id);
    
    console.log('在原始列表中的索引:', originalIndex);
    
    // 设置选中索引（使用显示索引）
    this.setData({
      selectedMotorFromList: displayIndex
    });
    
    // 调用原来的电机选择逻辑（使用原始索引）
    this.onMotorSelect({
      detail: { value: originalIndex }
    });
    
    wx.showToast({
      title: `已选择电机 ${selectedMotor.model || '未知型号'}`,
      icon: 'success'
    });
    
    console.log('=== 选择电机结束 ===');
  },

  /**
   * 取消选中
   */
  cancelSelection() {
    console.log('=== 取消选择开始 ===');
    console.log('当前 selectedMotorFromList:', this.data.selectedMotorFromList);
    
    this.setData({
      selectedMotorFromList: null,
      selectedMotor: {}
    });
    
    console.log('取消后 selectedMotorFromList:', this.data.selectedMotorFromList);
    
    wx.showToast({
      title: '已取消选择',
      icon: 'success'
    });
    
    console.log('=== 取消选择结束 ===');
  },

  /**
   * 输出电机与控制方案
   */
  async outputMotorSolution() {
    // 检查是否选择了电机
    if (!this.data.selectedMotor || !this.data.selectedMotor.model) {
      wx.showToast({
        title: '请先选择电机',
        icon: 'none'
      });
      return;
    }

    // 检查是否有保存的图片
    if (!this.data.db_id) {
      wx.showToast({
        title: '请先保存曲线图',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '生成方案中...'
    });

    try {
      // 1. 获取用户信息
      const app = getApp();
      const userInfo = app.globalData.userInfo || {};
      
      // 2. 准备电机信息纯文本格式
      const motorResults = this.formatMotorInfoAsText(this.data.selectedMotor);
      
      // 3. 从数据库获取保存的图片文件ID
      const savedData = await this.getSavedCalculationData();
      
      // 4. 准备云函数参数 - 传递文件ID而不是URL
      const params = {
        date: new Date().toLocaleDateString('zh-CN'),
        action: '电机选型报告',
        company_name: userInfo.company || '未知公司',
        name: userInfo.nickName || app.globalData.openid,
        phone: userInfo.phone || '未知',
        image1_fileId: savedData.speedChartFileId || '',
        image2_fileId: savedData.forceChartFileId || '',
        results: motorResults
      };

      // 5. 调用云函数生成Excel
      const result = await wx.cloud.callFunction({
        name: 'exportpdf',
        data: { params }
      });


      if (result.result.success) {
        // 6. 更新数据库中的选择电机信息和Excel文件ID
        try {
          const updateResult = await wx.cloud.callFunction({
            name: 'motor_db',
            data: {
              action: 'update_calculation',
              data: {
                recordId: this.data.db_id,
                selectedMotor: this.data.selectedMotor,
                excelFileId: result.result.fileID  // 保存Excel文件ID到数据库
              }
            }
          });
          
                  if (updateResult.result.success) {
          console.log('选择电机信息和Excel文件ID已更新到数据库');
          console.log('Excel文件ID:', result.result.fileID);
        } else {
          console.warn('更新数据库失败:', updateResult.result.message);
        }
      } catch (updateError) {
        console.error('更新数据库时出错:', updateError);
        // 不影响主流程，只记录错误
      }

      console.log('=== 准备更新阶段状态 ===');
      // 7. 更新阶段状态
      const stageStatus = this.data.stageStatus;
      stageStatus[3] = 'success';
      console.log('更新阶段状态:', stageStatus);
      
      this.setData({
        stageStatus: stageStatus,
        hasExportedSolution: true // 标记已经导出过控制方案
      });
      console.log('setData 完成');

      wx.hideLoading();
      console.log('hideLoading 完成');

      console.log('=== 准备显示 modal ===');
      console.log('selectedMotor.model:', this.data.selectedMotor.model);
      console.log('result.result.fileID:', result.result.fileID);
      
      wx.showModal({
        title: '方案生成完成',
        content: `已为您生成 ${this.data.selectedMotor.model} 的完整控制方案Excel文件`,
        confirmText: '获取链接',
        cancelText: '关闭',
        success: (res) => {
          console.log('modal success callback:', res);
          if (res.confirm) {
            this.downloadExcel(result.result.fileID);
          }
        },
        fail: (error) => {
          console.error('modal fail callback:', error);
        },
        complete: () => {
          console.log('modal complete callback');
        }
      });
      console.log('showModal 调用完成');
      } else {
        throw new Error(result.result.error || 'Excel生成失败');
      }

    } catch (error) {
      wx.hideLoading();
      console.error('生成方案失败:', error);
      
      wx.showModal({
        title: '生成失败',
        content: error.message || '网络异常，请稍后重试',
        showCancel: false,
        confirmText: '确定'
      });
    }
  },

  /**
   * 跳转到报告详情页
   */
  goToReportDetail() {
    if (!this.data.db_id) {
      wx.showToast({
        title: '数据异常，无法跳转',
        icon: 'none'
      });
      return;
    }

    wx.navigateTo({
      url: `/pages/search-detail/search-detail?id=${this.data.db_id}`
    });
  },

  /**
   * 格式化电机信息为纯文本格式
   */
  formatMotorInfoAsText(motor) {
    if (!motor || !motor.model) {
      return '未选择电机';
    }

    const formatValue = (value, unit = '') => {
      if (value === undefined || value === null || value === '--' || value === '') {
        return '未知';
      }
      return `${value}${unit}`;
    };

    const motorInfo = [
      `电机型号: ${motor.model}`,
      `峰值推力: ${formatValue(motor.maxForce, ' N')}`,
      `持续推力(100℃): ${formatValue(motor.continuousForce, ' N')}`,
      `磁吸力: ${formatValue(motor.forwardSuction, ' N')}`,
      `峰值电流: ${formatValue(motor.maxCurrent, ' A')}`,
      `持续电流(100℃): ${formatValue(motor.continuousCurrent, ' A')}`,
      `力常数: ${formatValue(motor.forceConstant, ' N/A')}`,
      `反电动势常数: ${formatValue(motor.backEmf, ' V·s/m')}`,
      `线电阻(25℃): ${formatValue(motor.lineResistance, ' Ω')}`,
      `线电感: ${formatValue(motor.lineInductance, ' mH')}`,
      `电气时间常数: ${formatValue(motor.timeConstant, ' ms')}`,
      `电机常数(25℃): ${formatValue(motor.motorConstant, ' N/√W')}`,
      `最高线圈温度: ${formatValue(motor.maxCoilTemp, ' ℃')}`,
      `最高母线电压: ${formatValue(motor.maxVoltage, ' V')}`,
      `线圈长度: ${formatValue(motor.primaryLength, ' mm')}`,
      `线圈质量: ${formatValue(motor.primaryMass, ' kg')}`,
      `磁轨质量(每米): ${formatValue(motor.secondaryMass, ' kg/m')}`,
      `电磁周期: ${formatValue(motor.electromagneticPeriod, ' mm')}`,
      `冷却方式: ${motor.coolingMethod}`,
      `电机类型: ${motor.coreType}`
    ];

    return motorInfo.join('\n');
  },

  /**
   * 获取保存的计算数据（包括图片文件ID）
   */
  async getSavedCalculationData() {
    try {
      const result = await wx.cloud.callFunction({
        name: 'motor_db',
        data: {
          action: 'get_calculation',
          data: { recordId: this.data.db_id }
        }
      });

      if (result.result.success && result.result.data) {
        const data = result.result.data;
        
        return {
          speedChartFileId: data.speedChartFileId,
          forceChartFileId: data.forceChartFileId,
          ...data
        };
      } else {
        throw new Error('获取保存数据失败');
      }
    } catch (error) {
      console.error('获取保存数据失败:', error);
      return {
        speedChartFileId: '',
        forceChartFileId: ''
      };
    }
  },

  /**
   * 获取云存储文件的临时URL
   */
  async getTempFileURL(fileId) {
    try {
      if (!fileId) {
        return './empty.png';
      }

      const result = await wx.cloud.getTempFileURL({
        fileList: [fileId]
      });

      if (result.fileList && result.fileList.length > 0 && result.fileList[0].status === 0) {
        return result.fileList[0].tempFileURL;
      } else {
        console.warn('获取临时URL失败:', result);
        return './empty.png';
      }
    } catch (error) {
      console.error('获取临时URL失败:', error);
      return './empty.png';
    }
  },

  /**
   * 下载PDF文件
   */
  async downloadPDF(fileID) {
    try {
      wx.showLoading({
        title: '准备下载...'
      });

      // 获取临时下载链接
      const result = await wx.cloud.getTempFileURL({
        fileList: [fileID]
      });

      wx.hideLoading();

      if (result.fileList && result.fileList.length > 0 && result.fileList[0].status === 0) {
        const tempFileURL = result.fileList[0].tempFileURL;
        
        // 下载文件到本地
        wx.downloadFile({
          url: tempFileURL,
          success: (res) => {
            if (res.statusCode === 200) {
              // 保存到相册或文件管理器
              wx.saveFile({
                tempFilePath: res.tempFilePath,
                success: (saveRes) => {
                  wx.showToast({
                    title: '下载成功',
                    icon: 'success'
                  });
                  console.log('文件保存路径:', saveRes.savedFilePath);
                },
                fail: (err) => {
                  console.error('保存文件失败:', err);
                  wx.showToast({
                    title: '保存失败',
                    icon: 'none'
                  });
                }
              });
            }
          },
          fail: (err) => {
            console.error('下载失败:', err);
            wx.showToast({
              title: '下载失败',
              icon: 'none'
            });
          }
        });
      } else {
        throw new Error('获取下载链接失败');
      }
    } catch (error) {
      wx.hideLoading();
      console.error('下载PDF失败:', error);
      wx.showToast({
        title: '下载失败',
        icon: 'none'
      });
    }
  },

  /**
   * 生成Excel下载链接
   */
  async downloadExcel(fileID) {
    try {
      wx.showLoading({
        title: '生成下载链接...'
      });

      // 获取临时下载链接
      const result = await wx.cloud.getTempFileURL({
        fileList: [fileID]
      });

      wx.hideLoading();

      console.log(result)

      if (result.fileList && result.fileList.length > 0 && result.fileList[0].status === 0) {
        const tempFileURL = result.fileList[0].tempFileURL;
        
        // 显示下载链接给用户
        wx.showModal({
          title: 'Excel下载链接已生成',
          content: `下载链接有效期：2小时\n点击"复制链接"可复制到剪贴板`,
          confirmText: '复制链接',
          cancelText: '关闭',
          success: (res) => {
            if (res.confirm) {
              // 复制链接到剪贴板
              wx.setClipboardData({
                data: tempFileURL,
                success: () => {
                  wx.showToast({
                    title: '链接已复制',
                    icon: 'success'
                  });
                },
                fail: (err) => {
                  console.error('复制失败:', err);
                  wx.showToast({
                    title: '复制失败',
                    icon: 'none'
                  });
                }
              });
            }
          }
        });
        
        console.log('Excel下载链接已生成:', tempFileURL);
      } else {
        throw new Error('获取Excel下载链接失败');
      }
    } catch (error) {
      wx.hideLoading();
      console.error('生成Excel下载链接失败:', error);
      wx.showToast({
        title: '生成链接失败',
        icon: 'none'
      });
    }
  },

  /**
   * 返回上一步
   */
  goToPreviousStage() {
    if (this.data.currentStage > 1) {
      this.setData({
        currentStage: this.data.currentStage - 1,
        hasReturnedFromNext: true, // 标记从下一阶段返回
        formChanged: false, // 重置表单变化标记
        stage1FormChanged: false // 重置阶段1表单变化标记
      });

      wx.pageScrollTo({
        scrollTop: 0,
        duration: 300
      });
    }
  },

  /**
   * 进入下一步
   */
  goToNextStage() {
    if (this.data.currentStage < 4) {
      const nextStage = this.data.currentStage + 1;
      this.setData({
        currentStage: nextStage,
        // 只有当超过之前的最大阶段时，才清除返回标记
        hasReturnedFromNext: nextStage <= this.data.maxReachedStage
      });

      wx.pageScrollTo({
        scrollTop: 0,
        duration: 300
      });
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
    console.log('计算页面隐藏');
    // 清理可能的定时器或异步操作
    this.clearTimers();
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    console.log('计算页面卸载');
    // 清理所有定时器和异步操作
    this.clearTimers();
  },

  /**
   * 清理定时器
   */
  clearTimers() {
    // 清理可能存在的定时器
    if (this.calculateTimer) {
      clearTimeout(this.calculateTimer);
      this.calculateTimer = null;
    }
    if (this.saveTimer) {
      clearTimeout(this.saveTimer);
      this.saveTimer = null;
    }
    if (this.filterTimer) {
      clearTimeout(this.filterTimer);
      this.filterTimer = null;
    }
    if (this.outputTimer) {
      clearTimeout(this.outputTimer);
      this.outputTimer = null;
    }
  },

  /**
   * 转换表单数据类型
   * 将字符串数字转换为真正的数字类型
   */
  convertFormDataTypes(formData) {
    // 定义需要转换为数字的字段
    const numberFields = [
      'accelerationTime',
      'runningTime', 
      'totalMass',
      'totalDistance',
      'totalTime',
      'maxAcceleration',
      'maxSpeed',
      'dwellTime',
      'inclineAngle',
      'ambientTemp',
      'reactionForce',
      'estimatedResistance',
      'frictionCoeff',
      'forwardSuction',
      'workResistance',
      'dragChainResistance',
      'frictionForce'
    ];

    // 创建转换后的数据副本
    const convertedData = { ...formData };

    // 转换数字字段
    numberFields.forEach(field => {
      if (convertedData[field] !== undefined && convertedData[field] !== '') {
        const numberValue = parseFloat(convertedData[field]);
        // 只有当转换成功且不是NaN时才赋值
        if (!isNaN(numberValue)) {
          convertedData[field] = numberValue;
        } else {
          // 如果转换失败，设为0
          convertedData[field] = 0;
        }
      } else {
        // 空值或undefined设为0
        convertedData[field] = 0;
      }
    });

    console.log('数据类型转换完成:', {
      original: formData,
      converted: convertedData
    });

    return convertedData;
  },

  /**
   * 转换计算结果数据类型
   * 将字符串数字转换为真正的数字类型
   */
  convertCalcResultsTypes(calcResults) {
    if (!calcResults || typeof calcResults !== 'object') {
      return calcResults;
    }

    // 定义需要转换为数字的字段（来自cal函数的返回值）
    const numberFields = [
      'acceleration',      // 加速时间、减速时间
      'constantSpeed',     // 匀速时间
      'totalCycle',        // 总循环周期
      'peakForce',         // 峰值推力
      'continuousForce',   // 持续推力
      'supportForce'       // 支持推力
    ];

    // 定义数组字段（图表数据）
    const arrayFields = [
      'speedTimeXPoints',  // 速度时间X轴数据
      'speedTimeYPoints',  // 速度时间Y轴数据
      'forceTimeXPoints',  // 力时间X轴数据
      'forceTimeYPoints'   // 力时间Y轴数据
    ];

    // 创建转换后的数据副本
    const convertedData = { ...calcResults };

    // 转换数字字段
    numberFields.forEach(field => {
      if (convertedData[field] !== undefined && convertedData[field] !== '') {
        const numberValue = parseFloat(convertedData[field]);
        if (!isNaN(numberValue)) {
          convertedData[field] = numberValue;
        } else {
          convertedData[field] = 0;
        }
      }
    });

    // 转换数组字段中的数字
    arrayFields.forEach(field => {
      if (Array.isArray(convertedData[field])) {
        convertedData[field] = convertedData[field].map(item => {
          const numberValue = parseFloat(item);
          return !isNaN(numberValue) ? numberValue : 0;
        });
      }
    });

    console.log('计算结果数据类型转换完成:', {
      original: calcResults,
      converted: convertedData
    });

    return convertedData;
  },

  /**
   * 标记表单已变化
   */
  markFormChanged(field) {
    // 定义阶段1的字段
    const stage1Fields = [
      'machineName', 'axisName', 'motionMode', 'motionShape', 'accelerationTime', 'runningTime',
      'totalMass', 'totalDistance', 'totalTime', 'maxAcceleration', 'maxSpeed', 'dwellTime',
      'inclineAngle', 'ambientTemp', 'reactionForce', 'estimatedResistance',
      'frictionCoeff', 'forwardSuction', 'workResistance', 'dragChainResistance', 'frictionForce'
    ];

    const updateData = {
      formChanged: true
    };

    // 如果是阶段1的字段，也标记阶段1表单已变化
    if (stage1Fields.includes(field)) {
      updateData.stage1FormChanged = true;
    }

    this.setData(updateData);
  },

  /**
   * 检查是否可以计算
   */
  canCalculate() {
    // 如果当前阶段超过了之前到达的最大阶段，或者没有返回标记，可以直接计算
    if (this.data.currentStage > this.data.maxReachedStage || !this.data.hasReturnedFromNext) {
      return true;
    }

    // 如果从下一阶段返回，需要表单有变化才能计算
    if (!this.data.formChanged) {
      wx.showToast({
        title: '请先修改表单参数',
        icon: 'none'
      });
      return false;
    }

    return true;
  },

  /**
   * 检查是否可以保存曲线
   */
  canSaveCurve() {
    // 如果当前阶段超过了之前到达的最大阶段，或者没有返回标记，可以直接保存
    if (this.data.currentStage > this.data.maxReachedStage || !this.data.hasReturnedFromNext) {
      return true;
    }

    // 如果从下一阶段返回，需要阶段1表单有变化才能保存曲线
    if (!this.data.stage1FormChanged) {
      wx.showToast({
        title: '请先修改阶段1的表单参数',
        icon: 'none'
      });
      return false;
    }

    return true;
  },



  async uploadChartToCloud(chart_id) {
    // 获取 line-chart 组件实例
    const lineChartComponent = this.selectComponent(chart_id);
    if (!lineChartComponent) {
      console.error('无法找到 line-chart 组件');
      wx.showToast({
        title: '保存失败：找不到图表组件',
        icon: 'error'
      });
      return;
    }

    try {
      // 调用组件的保存方法
      const tempFilePath = await lineChartComponent.saveToImage();

      // 生成唯一文件名（使用时间戳+随机数）
      const generateUniqueId = () => {
        const timestamp = Date.now();
        const random = Math.floor(Math.random() * 10000);
        return `${timestamp}_${random}`;
      };
      const uniqueId = generateUniqueId();
      
      // 清理chart_id中的特殊字符，只保留字母数字和连字符
      const cleanChartId = chart_id.replace(/[^a-zA-Z0-9\-]/g, '');
      
      const getYearMonth =  function() {
        const date = new Date();
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从 0 开始，需 +1
        return `${year}${month}`;
      }
      const cloudPath = `motor_images/${getYearMonth()}/${cleanChartId}-${uniqueId}.png`;
      
      console.log(`上传图表到云存储: ${chart_id} -> ${cloudPath}`);
      
      // 上传到云存储
     const result =  await wx.cloud.uploadFile({
        cloudPath: cloudPath,
        filePath: tempFilePath,
      });
      
      console.log(`图表上传成功: ${result.fileID}`);
      return result
    } catch (error) {
      console.error('保存图表失败:', error);
      wx.showToast({
        title: '保存失败',
        icon: 'error'
      });
      throw error
    }


  },

});